home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2007 December / PCWKCD1207B.iso / Blogowanie poza sfera / Flock 1.0 beta / flock-1.0RC3.en-US.win32.exe / flock / components / nsSessionStore.js < prev    next >
Text File  |  2007-10-18  |  75KB  |  2,181 lines
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  3.  *
  4.  * The contents of this file are subject to the Mozilla Public License Version
  5.  * 1.1 (the "License"); you may not use this file except in compliance with
  6.  * the License. You may obtain a copy of the License at
  7.  * http://www.mozilla.org/MPL/
  8.  *
  9.  * Software distributed under the License is distributed on an "AS IS" basis,
  10.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11.  * for the specific language governing rights and limitations under the
  12.  * License.
  13.  *
  14.  * The Original Code is the nsSessionStore component.
  15.  *
  16.  * The Initial Developer of the Original Code is
  17.  * Simon B├╝nzli <zeniko@gmail.com>
  18.  *
  19.  * Portions created by the Initial Developer are Copyright (C) 2006
  20.  * the Initial Developer. All Rights Reserved.
  21.  *
  22.  * Contributor(s):
  23.  * Dietrich Ayala <autonome@gmail.com>
  24.  *
  25.  * Alternatively, the contents of this file may be used under the terms of
  26.  * either the GNU General Public License Version 2 or later (the "GPL"), or
  27.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28.  * in which case the provisions of the GPL or the LGPL are applicable instead
  29.  * of those above. If you wish to allow use of your version of this file only
  30.  * under the terms of either the GPL or the LGPL, and not to allow others to
  31.  * use your version of this file under the terms of the MPL, indicate your
  32.  * decision by deleting the provisions above and replace them with the notice
  33.  * and other provisions required by the GPL or the LGPL. If you do not delete
  34.  * the provisions above, a recipient may use your version of this file under
  35.  * the terms of any one of the MPL, the GPL or the LGPL.
  36.  *
  37.  * ***** END LICENSE BLOCK ***** */
  38.  
  39. /**
  40.  * Session Storage and Restoration
  41.  * 
  42.  * Overview
  43.  * This service keeps track of a user's session, storing the various bits
  44.  * required to return the browser to it's current state. The relevant data is 
  45.  * stored in memory, and is periodically saved to disk in a file in the 
  46.  * profile directory. The service is started at first window load, in
  47.  * delayedStartup, and will restore the session from the data received from
  48.  * the nsSessionStartup service.
  49.  */
  50.  
  51. /* :::::::: Constants and Helpers ::::::::::::::: */
  52.  
  53. const Cc = Components.classes;
  54. const Ci = Components.interfaces;
  55. const Cr = Components.results;
  56.  
  57. const CID = Components.ID("{5280606b-2510-4fe0-97ef-9b5a22eafe6b}");
  58. const CONTRACT_ID = "@mozilla.org/browser/sessionstore;1";
  59. const CLASS_NAME = "Browser Session Store Service";
  60.  
  61. const STATE_STOPPED = 0;
  62. const STATE_RUNNING = 1;
  63. const STATE_QUITTING = -1;
  64.  
  65. const STATE_STOPPED_STR = "stopped";
  66. const STATE_RUNNING_STR = "running";
  67.  
  68. const PRIVACY_NONE = 0;
  69. const PRIVACY_ENCRYPTED = 1;
  70. const PRIVACY_FULL = 2;
  71.  
  72. /* :::::::: Pref Defaults :::::::::::::::::::: */
  73.  
  74. // whether the service is enabled
  75. const DEFAULT_ENABLED = true;
  76.  
  77. // minimal interval between two save operations (in milliseconds)
  78. const DEFAULT_INTERVAL = 10000;
  79.  
  80. // maximum number of closed tabs remembered (per window)
  81. const DEFAULT_MAX_TABS_UNDO = 10;
  82.  
  83. // maximal amount of POSTDATA to be stored (in bytes, -1 = all of it)
  84. const DEFAULT_POSTDATA = 0;
  85.  
  86. // on which sites to save text data, POSTDATA and cookies
  87. // (0 = everywhere, 1 = unencrypted sites, 2 = nowhere)
  88. const DEFAULT_PRIVACY_LEVEL = PRIVACY_ENCRYPTED;
  89.  
  90. // resume the current session at startup just this once
  91. const DEFAULT_RESUME_SESSION_ONCE = false;
  92.  
  93. // resume the current session at startup if it had previously crashed
  94. const DEFAULT_RESUME_FROM_CRASH = true;
  95.  
  96. // global notifications observed
  97. const OBSERVING = [
  98.   "domwindowopened", "domwindowclosed",
  99.   "quit-application-requested", "quit-application-granted",
  100.   "quit-application", "browser:purge-session-history"
  101. ];
  102.  
  103. /*
  104. XUL Window properties to (re)store
  105. Restored in restoreDimensions_proxy()
  106. */
  107. const WINDOW_ATTRIBUTES = ["width", "height", "screenX", "screenY", "sizemode"];
  108.  
  109. /* 
  110. Hideable window features to (re)store
  111. Restored in restoreWindowFeatures()
  112. */
  113. const WINDOW_HIDEABLE_FEATURES = [
  114.   "menubar", "toolbar", "locationbar", 
  115.   "personalbar", "statusbar", "scrollbars"
  116. ];
  117.  
  118. /*
  119. docShell capabilities to (re)store
  120. Restored in restoreHistory()
  121. eg: browser.docShell["allow" + aCapability] = false;
  122. */
  123. const CAPABILITIES = [
  124.   "Subframes", "Plugins", "Javascript", "MetaRedirects", "Images"
  125. ];
  126.  
  127. function debug(aMsg) {
  128.   aMsg = ("SessionStore: " + aMsg).replace(/\S{80}/g, "$&\n");
  129.   Cc["@mozilla.org/consoleservice;1"].getService(Ci.nsIConsoleService)
  130.                                      .logStringMessage(aMsg);
  131. }
  132.  
  133. /* :::::::: The Service ::::::::::::::: */
  134.  
  135. function SessionStoreService() {
  136. }
  137.  
  138. SessionStoreService.prototype = {
  139.  
  140.   // xul:tab attributes to (re)store (extensions might want to hook in here)
  141.   xulAttributes: [],
  142.  
  143.   // set default load state
  144.   _loadState: STATE_STOPPED,
  145.  
  146.   // minimal interval between two save operations (in milliseconds)
  147.   _interval: DEFAULT_INTERVAL,
  148.  
  149.   // when crash recovery is disabled, session data is not written to disk
  150.   _resume_from_crash: DEFAULT_RESUME_FROM_CRASH,
  151.  
  152.   // time in milliseconds (Date.now()) when the session was last written to file
  153.   _lastSaveTime: 0, 
  154.  
  155.   // states for all currently opened windows
  156.   _windows: {},
  157.  
  158.   // in case the last closed window ain't a navigator:browser one
  159.   _lastWindowClosed: null,
  160.  
  161.   // not-"dirty" windows usually don't need to have their data updated
  162.   _dirtyWindows: {},
  163.  
  164.   // flag all windows as dirty
  165.   _dirty: false,
  166.  
  167. /* ........ Global Event Handlers .............. */
  168.  
  169.   /**
  170.    * Initialize the component
  171.    */
  172.   init: function sss_init(aWindow) {
  173.     if (!aWindow || this._loadState == STATE_RUNNING) {
  174.       // make sure that all browser windows which try to initialize
  175.       // SessionStore are really tracked by it
  176.       if (aWindow && (!aWindow.__SSi || !this._windows[aWindow.__SSi]))
  177.         this.onLoad(aWindow);
  178.       return;
  179.     }
  180.  
  181.     this._prefBranch = Cc["@mozilla.org/preferences-service;1"].
  182.                        getService(Ci.nsIPrefService).getBranch("browser.");
  183.     this._prefBranch.QueryInterface(Ci.nsIPrefBranch2);
  184.  
  185.     // if the service is disabled, do not init 
  186.     if (!this._getPref("sessionstore.enabled", DEFAULT_ENABLED))
  187.       return;
  188.  
  189.     var observerService = Cc["@mozilla.org/observer-service;1"].
  190.                           getService(Ci.nsIObserverService);
  191.  
  192.     OBSERVING.forEach(function(aTopic) {
  193.       observerService.addObserver(this, aTopic, true);
  194.     }, this);
  195.     
  196.     // get interval from prefs - used often, so caching/observing instead of fetching on-demand
  197.     this._interval = this._getPref("sessionstore.interval", DEFAULT_INTERVAL);
  198.     this._prefBranch.addObserver("sessionstore.interval", this, true);
  199.     
  200.     // get crash recovery state from prefs and allow for proper reaction to state changes
  201.     this._resume_from_crash = this._getPref("sessionstore.resume_from_crash", DEFAULT_RESUME_FROM_CRASH);
  202.     this._prefBranch.addObserver("sessionstore.resume_from_crash", this, true);
  203.     
  204.     // observe prefs changes so we can modify stored data to match
  205.     this._prefBranch.addObserver("sessionstore.max_tabs_undo", this, true);
  206.  
  207.     // get file references
  208.     var dirService = Cc["@mozilla.org/file/directory_service;1"].
  209.                      getService(Ci.nsIProperties);
  210.     this._sessionFile = dirService.get("ProfD", Ci.nsILocalFile);
  211.     this._sessionFileBackup = this._sessionFile.clone();
  212.     this._sessionFile.append("sessionstore.js");
  213.     this._sessionFileBackup.append("sessionstore.bak");
  214.    
  215.     // get string containing session state
  216.     var iniString;
  217.     try {
  218.       var ss = Cc["@mozilla.org/browser/sessionstartup;1"].
  219.                getService(Ci.nsISessionStartup);
  220.       if (ss.doRestore())
  221.         iniString = ss.state;
  222.     }
  223.     catch(ex) { dump(ex + "\n"); } // no state to restore, which is ok
  224.  
  225.     if (iniString) {
  226.       try {
  227.         // parse the session state into JS objects
  228.         this._initialState = this._safeEval(iniString);
  229.         // set bool detecting crash
  230.         this._lastSessionCrashed =
  231.           this._initialState.session && this._initialState.session.state &&
  232.           this._initialState.session.state == STATE_RUNNING_STR;
  233.         
  234.         // restore the features of the first window from localstore.rdf
  235.         WINDOW_ATTRIBUTES.forEach(function(aAttr) {
  236.           delete this._initialState.windows[0][aAttr];
  237.         }, this);
  238.         delete this._initialState.windows[0].hidden;
  239.       }
  240.       catch (ex) { debug("The session file is invalid: " + ex); }
  241.     }
  242.     
  243.     // if last session crashed, backup the session
  244.     if (this._lastSessionCrashed) {
  245.       try {
  246.         this._writeFile(this._sessionFileBackup, iniString);
  247.       }
  248.       catch (ex) { } // nothing else we can do here
  249.     }
  250.  
  251.     // remove the session data files if crash recovery is disabled
  252.     if (!this._resume_from_crash)
  253.       this._clearDisk();
  254.     
  255.     // As this is called at delayedStartup, restoration must be initiated here
  256.     this.onLoad(aWindow);
  257.   },
  258.  
  259.   /**
  260.    * Called on application shutdown, after notifications:
  261.    * quit-application-granted, quit-application
  262.    */
  263.   _uninit: function sss_uninit() {
  264.     if (this._doResumeSession()) { // save all data for session resuming 
  265.       this.saveState(true);
  266.     }
  267.     else { // discard all session related data 
  268.       this._clearDisk();
  269.     }
  270.     // Make sure to break our cycle with the save timer
  271.     if (this._saveTimer) {
  272.       this._saveTimer.cancel();
  273.       this._saveTimer = null;
  274.     }
  275.   },
  276.  
  277.   /**
  278.    * Handle notifications
  279.    */
  280.   observe: function sss_observe(aSubject, aTopic, aData) {
  281.     // for event listeners
  282.     var _this = this;
  283.  
  284.     switch (aTopic) {
  285.     case "domwindowopened": // catch new windows
  286.       aSubject.addEventListener("load", function(aEvent) {
  287.         aEvent.currentTarget.removeEventListener("load", arguments.callee, false);
  288.         _this.onLoad(aEvent.currentTarget);
  289.         }, false);
  290.       break;
  291.     case "domwindowclosed": // catch closed windows
  292.       this.onClose(aSubject);
  293.       break;
  294.     case "quit-application-requested":
  295.       // get a current snapshot of all windows
  296.       this._forEachBrowserWindow(function(aWindow) {
  297.         this._collectWindowData(aWindow);
  298.       });
  299.       this._dirtyWindows = [];
  300.       this._dirty = false;
  301.       break;
  302.     case "quit-application-granted":
  303.       // freeze the data at what we've got (ignoring closing windows)
  304.       this._loadState = STATE_QUITTING;
  305.       break;
  306.     case "quit-application":
  307.       if (aData == "restart")
  308.         this._prefBranch.setBoolPref("sessionstore.resume_session_once", true);
  309.       this._loadState = STATE_QUITTING; // just to be sure
  310.       this._uninit();
  311.       break;
  312.     case "browser:purge-session-history": // catch sanitization 
  313.       this._forEachBrowserWindow(function(aWindow) {
  314.         Array.forEach(aWindow.getBrowser().browsers, function(aBrowser) {
  315.           delete aBrowser.parentNode.__SS_data;
  316.         });
  317.       });
  318.       this._lastWindowClosed = null;
  319.       this._clearDisk();
  320.       // also clear all data about closed tabs
  321.       for (ix in this._windows) {
  322.         this._windows[ix]._closedTabs = [];
  323.       }
  324.       // give the tabbrowsers a chance to clear their histories first
  325.       var win = this._getMostRecentBrowserWindow();
  326.       if (win)
  327.         win.setTimeout(function() { _this.saveState(true); }, 0);
  328.       else
  329.         this.saveState(true);
  330.       break;
  331.     case "nsPref:changed": // catch pref changes
  332.       switch (aData) {
  333.       // if the user decreases the max number of closed tabs they want
  334.       // preserved update our internal states to match that max
  335.       case "sessionstore.max_tabs_undo":
  336.         var ix;
  337.         for (ix in this._windows) {
  338.           this._windows[ix]._closedTabs.splice(this._getPref("sessionstore.max_tabs_undo", DEFAULT_MAX_TABS_UNDO));
  339.         }
  340.         break;
  341.       case "sessionstore.interval":
  342.         this._interval = this._getPref("sessionstore.interval", this._interval);
  343.         // reset timer and save
  344.         if (this._saveTimer) {
  345.           this._saveTimer.cancel();
  346.           this._saveTimer = null;
  347.         }
  348.         this.saveStateDelayed(null, -1);
  349.         break;
  350.       case "sessionstore.resume_from_crash":
  351.         this._resume_from_crash = this._getPref("sessionstore.resume_from_crash", this._resume_from_crash);
  352.         // either create the file with crash recovery information or remove it
  353.         // (when _loadState is not STATE_RUNNING, that file is used for session resuming instead)
  354.         if (this._resume_from_crash)
  355.           this.saveState(true);
  356.         else if (this._loadState == STATE_RUNNING)
  357.           this._clearDisk();
  358.         break;
  359.       }
  360.       break;
  361.     case "timer-callback": // timer call back for delayed saving
  362.       this._saveTimer = null;
  363.       this.saveState();
  364.       break;
  365.     }
  366.   },
  367.  
  368. /* ........ Window Event Handlers .............. */
  369.  
  370.   /**
  371.    * Implement nsIDOMEventListener for handling various window and tab events
  372.    */
  373.   handleEvent: function sss_handleEvent(aEvent) {
  374.     switch (aEvent.type) {
  375.       case "load":
  376.         this.onTabLoad(aEvent.currentTarget.ownerDocument.defaultView, aEvent.currentTarget, aEvent);
  377.         break;
  378.       case "pageshow":
  379.         this.onTabLoad(aEvent.currentTarget.ownerDocument.defaultView, aEvent.currentTarget, aEvent);
  380.         break;
  381.       case "input":
  382.         this.onTabInput(aEvent.currentTarget.ownerDocument.defaultView, aEvent.currentTarget, aEvent);
  383.         break;
  384.       case "DOMAutoComplete":
  385.         this.onTabInput(aEvent.currentTarget.ownerDocument.defaultView, aEvent.currentTarget, aEvent);
  386.         break;
  387.       case "TabOpen":
  388.       case "TabClose":
  389.         var panelID = aEvent.originalTarget.linkedPanel;
  390.         var tabpanel = aEvent.originalTarget.ownerDocument.getElementById(panelID);
  391.         if (aEvent.type == "TabOpen") {
  392.           this.onTabAdd(aEvent.currentTarget.ownerDocument.defaultView, tabpanel);
  393.         }
  394.         else {
  395.           this.onTabClose(aEvent.currentTarget.ownerDocument.defaultView, aEvent.originalTarget);
  396.           this.onTabRemove(aEvent.currentTarget.ownerDocument.defaultView, tabpanel);
  397.         }
  398.         break;
  399.       case "TabSelect":
  400.         var tabpanels = aEvent.currentTarget.mPanelContainer;
  401.         this.onTabSelect(aEvent.currentTarget.ownerDocument.defaultView, tabpanels);
  402.         break;
  403.     }
  404.   },
  405.  
  406.   /**
  407.    * If it's the first window load since app start...
  408.    * - determine if we're reloading after a crash or a forced-restart
  409.    * - restore window state
  410.    * - restart downloads
  411.    * Set up event listeners for this window's tabs
  412.    * @param aWindow
  413.    *        Window reference
  414.    */
  415.   onLoad: function sss_onLoad(aWindow) {
  416.     // return if window has already been initialized
  417.     if (aWindow && aWindow.__SSi && this._windows[aWindow.__SSi])
  418.       return;
  419.  
  420.     var _this = this;
  421.  
  422.     // ignore non-browser windows and windows opened while shutting down
  423.     if (aWindow.document.documentElement.getAttribute("windowtype") != "navigator:browser" ||
  424.       this._loadState == STATE_QUITTING)
  425.       return;
  426.  
  427.     // assign it a unique identifier (timestamp)
  428.     aWindow.__SSi = "window" + Date.now();
  429.  
  430.     // and create its data object
  431.     this._windows[aWindow.__SSi] = { tabs: [], selected: 0, _closedTabs: [] };
  432.     
  433.     // perform additional initialization when the first window is loading
  434.     if (this._loadState == STATE_STOPPED) {
  435.       this._loadState = STATE_RUNNING;
  436.       this._lastSaveTime = Date.now();
  437.       
  438.       // don't save during the first five seconds
  439.       // (until most of the pages have been restored)
  440.       this.saveStateDelayed(aWindow, 10000);
  441.  
  442.       // restore a crashed session resp. resume the last session if requested
  443.       if (this._initialState) {
  444.         // make sure that the restored tabs are first in the window
  445.         this._initialState._firstTabs = true;
  446.         this.restoreWindow(aWindow, this._initialState, this._isCmdLineEmpty(aWindow));
  447.         delete this._initialState;
  448.       }
  449.       
  450.       if (this._lastSessionCrashed) {
  451.         // restart any interrupted downloads
  452.         aWindow.setTimeout(function(){ _this.retryDownloads(aWindow); }, 0);
  453.       }
  454.     }
  455.     
  456.     var tabbrowser = aWindow.getBrowser();
  457.     var tabpanels = tabbrowser.mPanelContainer;
  458.     
  459.     // add tab change listeners to all already existing tabs
  460.     for (var i = 0; i < tabpanels.childNodes.length; i++) {
  461.       this.onTabAdd(aWindow, tabpanels.childNodes[i], true);
  462.     }
  463.     // notification of tab add/remove/selection
  464.     tabbrowser.addEventListener("TabOpen", this, true);
  465.     tabbrowser.addEventListener("TabClose", this, true);
  466.     tabbrowser.addEventListener("TabSelect", this, true);
  467.   },
  468.  
  469.   /**
  470.    * On window close...
  471.    * - remove event listeners from tabs
  472.    * - save all window data
  473.    * @param aWindow
  474.    *        Window reference
  475.    */
  476.   onClose: function sss_onClose(aWindow) {
  477.     // ignore windows not tracked by SessionStore
  478.     if (!aWindow.__SSi || !this._windows[aWindow.__SSi]) {
  479.       return;
  480.     }
  481.     
  482.     var tabbrowser = aWindow.getBrowser();
  483.     var tabpanels = tabbrowser.mPanelContainer;
  484.  
  485.     tabbrowser.removeEventListener("TabOpen", this, true);
  486.     tabbrowser.removeEventListener("TabClose", this, true);
  487.     tabbrowser.removeEventListener("TabSelect", this, true);
  488.     
  489.     for (var i = 0; i < tabpanels.childNodes.length; i++) {
  490.       this.onTabRemove(aWindow, tabpanels.childNodes[i], true);
  491.     }
  492.     
  493.     if (this._loadState == STATE_RUNNING) { // window not closed during a regular shut-down 
  494.       // update all window data for a last time
  495.       this._collectWindowData(aWindow);
  496.       
  497.       // preserve this window's data (in case it was the last navigator:browser)
  498.       this._lastWindowClosed = this._windows[aWindow.__SSi];
  499.       this._lastWindowClosed.title = aWindow.content.document.title;
  500.       this._updateCookies([this._lastWindowClosed]);
  501.       
  502.       // clear this window from the list
  503.       delete this._windows[aWindow.__SSi];
  504.       
  505.       // save the state without this window to disk
  506.       this.saveStateDelayed();
  507.     }
  508.     
  509.     delete aWindow.__SSi;
  510.   },
  511.  
  512.   /**
  513.    * set up listeners for a new tab
  514.    * @param aWindow
  515.    *        Window reference
  516.    * @param aPanel
  517.    *        TabPanel reference
  518.    * @param aNoNotification
  519.    *        bool Do not save state if we're updating an existing tab
  520.    */
  521.   onTabAdd: function sss_onTabAdd(aWindow, aPanel, aNoNotification) {
  522.     aPanel.addEventListener("load", this, true);
  523.     aPanel.addEventListener("pageshow", this, true);
  524.     aPanel.addEventListener("input", this, true);
  525.     aPanel.addEventListener("DOMAutoComplete", this, true);
  526.     
  527.     if (!aNoNotification) {
  528.       this.saveStateDelayed(aWindow);
  529.     }
  530.   },
  531.  
  532.   /**
  533.    * remove listeners for a tab
  534.    * @param aWindow
  535.    *        Window reference
  536.    * @param aPanel
  537.    *        TabPanel reference
  538.    * @param aNoNotification
  539.    *        bool Do not save state if we're updating an existing tab
  540.    */
  541.   onTabRemove: function sss_onTabRemove(aWindow, aPanel, aNoNotification) {
  542.     aPanel.removeEventListener("load", this, true);
  543.     aPanel.removeEventListener("pageshow", this, true);
  544.     aPanel.removeEventListener("input", this, true);
  545.     aPanel.removeEventListener("DOMAutoComplete", this, true);
  546.     
  547.     delete aPanel.__SS_data;
  548.     delete aPanel.__SS_text;
  549.     
  550.     if (!aNoNotification) {
  551.       this.saveStateDelayed(aWindow);
  552.     }
  553.   },
  554.  
  555.   /**
  556.    * When a tab closes, collect it's properties
  557.    * @param aWindow
  558.    *        Window reference
  559.    * @param aTab
  560.    *        TabPanel reference
  561.    */
  562.   onTabClose: function sss_onTabClose(aWindow, aTab) {
  563.     // don't update our internal state if we don't have to
  564.     if (this._getPref("sessionstore.max_tabs_undo", DEFAULT_MAX_TABS_UNDO) == 0) {
  565.       return;
  566.     }
  567.     
  568.     // make sure that the tab related data is up-to-date
  569.     this._saveWindowHistory(aWindow);
  570.     this._updateTextAndScrollData(aWindow);
  571.     
  572.     // store closed-tab data for undo
  573.     var tabState = this._windows[aWindow.__SSi].tabs[aTab._tPos];
  574.     if (tabState && (tabState.entries.length > 1 ||
  575.         tabState.entries[0].url != "about:blank")) {
  576.       this._windows[aWindow.__SSi]._closedTabs.unshift({
  577.         state: tabState,
  578.         title: aTab.getAttribute("label"),
  579.         pos: aTab._tPos
  580.       });
  581.       var maxTabsUndo = this._getPref("sessionstore.max_tabs_undo", DEFAULT_MAX_TABS_UNDO);
  582.       var length = this._windows[aWindow.__SSi]._closedTabs.length;
  583.       if (length > maxTabsUndo)
  584.         this._windows[aWindow.__SSi]._closedTabs.splice(maxTabsUndo, length - maxTabsUndo);
  585.     }
  586.   },
  587.  
  588.   /**
  589.    * When a tab loads, save state.
  590.    * @param aWindow
  591.    *        Window reference
  592.    * @param aPanel
  593.    *        TabPanel reference
  594.    * @param aEvent
  595.    *        Event obj
  596.    */
  597.   onTabLoad: function sss_onTabLoad(aWindow, aPanel, aEvent) { 
  598.     // react on "load" and solitary "pageshow" events (the first "pageshow"
  599.     // following "load" is too late for deleting the data caches)
  600.     if (aEvent.type != "load" && !aEvent.persisted) {
  601.       return;
  602.     }
  603.     
  604.     delete aPanel.__SS_data;
  605.     delete aPanel.__SS_text;
  606.     this.saveStateDelayed(aWindow);
  607.   },
  608.  
  609.   /**
  610.    * Called when a tabpanel sends the "input" notification 
  611.    * stores textarea data
  612.    * @param aWindow
  613.    *        Window reference
  614.    * @param aPanel
  615.    *        TabPanel reference
  616.    * @param aEvent
  617.    *        Event obj
  618.    */
  619.   onTabInput: function sss_onTabInput(aWindow, aPanel, aEvent) {
  620.     if (this._saveTextData(aPanel, aEvent.originalTarget)) {
  621.       this.saveStateDelayed(aWindow, 3000);
  622.     }
  623.   },
  624.  
  625.   /**
  626.    * When a tab is selected, save session data
  627.    * @param aWindow
  628.    *        Window reference
  629.    * @param aPanels
  630.    *        TabPanel reference
  631.    */
  632.   onTabSelect: function sss_onTabSelect(aWindow, aPanels) {
  633.     if (this._loadState == STATE_RUNNING) {
  634.       this._windows[aWindow.__SSi].selected = aPanels.selectedIndex;
  635.       this.saveStateDelayed(aWindow);
  636.     }
  637.   },
  638.  
  639. /* ........ nsISessionStore API .............. */
  640.  
  641.   getBrowserState: function sss_getBrowserState() {
  642.     return this._toJSONString(this._getCurrentState());
  643.   },
  644.  
  645.   setBrowserState: function sss_setBrowserState(aState) {
  646.     var window = this._getMostRecentBrowserWindow();
  647.     if (!window) {
  648.       this._openWindowWithState("(" + aState + ")");
  649.       return;
  650.     }
  651.  
  652.     // close all other browser windows
  653.     this._forEachBrowserWindow(function(aWindow) {
  654.       if (aWindow != window) {
  655.         aWindow.close();
  656.       }
  657.     });
  658.  
  659.     // restore to the given state
  660.     this.restoreWindow(window, "(" + aState + ")", true);
  661.   },
  662.  
  663.   getWindowState: function sss_getWindowState(aWindow) {
  664.     return this._toJSONString(this._getWindowState(aWindow));
  665.   },
  666.  
  667.   setWindowState: function sss_setWindowState(aWindow, aState, aOverwrite) {
  668.     this.restoreWindow(aWindow, "(" + aState + ")", aOverwrite);
  669.   },
  670.  
  671.   getClosedTabCount: function sss_getClosedTabCount(aWindow) {
  672.     return this._windows[aWindow.__SSi]._closedTabs.length;
  673.   },
  674.  
  675.   closedTabNameAt: function sss_closedTabNameAt(aWindow, aIx) {
  676.     var tabs = this._windows[aWindow.__SSi]._closedTabs;
  677.     
  678.     return aIx in tabs ? tabs[aIx].title : null;
  679.   },
  680.  
  681.   getClosedTabData: function sss_getClosedTabDataAt(aWindow) {
  682.     return this._toJSONString(this._windows[aWindow.__SSi]._closedTabs);
  683.   },
  684.  
  685.   undoCloseTab: function sss_undoCloseTab(aWindow, aIndex) {
  686.     var closedTabs = this._windows[aWindow.__SSi]._closedTabs;
  687.  
  688.     // default to the most-recently closed tab
  689.     aIndex = aIndex || 0;
  690.     
  691.     if (aIndex in closedTabs) {
  692.       var browser = aWindow.getBrowser();
  693.  
  694.       // fetch the data of closed tab, while removing it from the array
  695.       var closedTab = closedTabs.splice(aIndex, 1).shift();
  696.       var closedTabState = closedTab.state;
  697.  
  698.       // create a new tab
  699.       closedTabState._tab = browser.addTab();
  700.       
  701.       // restore the tab's position
  702.       browser.moveTabTo(closedTabState._tab, closedTab.pos);
  703.  
  704.       // restore tab content
  705.       this.restoreHistoryPrecursor(aWindow, [closedTabState], 1, 0, 0);
  706.     }
  707.     else {
  708.       Components.returnCode = Cr.NS_ERROR_INVALID_ARG;
  709.     }
  710.   },
  711.  
  712.   getWindowValue: function sss_getWindowValue(aWindow, aKey) {
  713.     if (aWindow.__SSi) {
  714.       var data = this._windows[aWindow.__SSi].extData || {};
  715.       return data[aKey] || "";
  716.     }
  717.     else {
  718.       Components.returnCode = Cr.NS_ERROR_INVALID_ARG;
  719.     }
  720.   },
  721.  
  722.   setWindowValue: function sss_setWindowValue(aWindow, aKey, aStringValue) {
  723.     if (aWindow.__SSi) {
  724.       if (!this._windows[aWindow.__SSi].extData) {
  725.         this._windows[aWindow.__SSi].extData = {};
  726.       }
  727.       this._windows[aWindow.__SSi].extData[aKey] = aStringValue;
  728.       this.saveStateDelayed(aWindow);
  729.     }
  730.     else {
  731.       Components.returnCode = Cr.NS_ERROR_INVALID_ARG;
  732.     }
  733.   },
  734.  
  735.   deleteWindowValue: function sss_deleteWindowValue(aWindow, aKey) {
  736.     if (this._windows[aWindow.__SSi].extData[aKey])
  737.       delete this._windows[aWindow.__SSi].extData[aKey];
  738.     else
  739.       Components.returnCode = Cr.NS_ERROR_INVALID_ARG;
  740.   },
  741.  
  742.   getTabValue: function sss_getTabValue(aTab, aKey) {
  743.     var data = aTab.__SS_extdata || {};
  744.     return data[aKey] || "";
  745.   },
  746.  
  747.   setTabValue: function sss_setTabValue(aTab, aKey, aStringValue) {
  748.     if (!aTab.__SS_extdata) {
  749.       aTab.__SS_extdata = {};
  750.     }
  751.     aTab.__SS_extdata[aKey] = aStringValue;
  752.     this.saveStateDelayed(aTab.ownerDocument.defaultView);
  753.   },
  754.  
  755.   deleteTabValue: function sss_deleteTabValue(aTab, aKey) {
  756.     if (aTab.__SS_extdata[aKey])
  757.       delete aTab.__SS_extdata[aKey];
  758.     else
  759.       Components.returnCode = Cr.NS_ERROR_INVALID_ARG;
  760.   },
  761.  
  762.  
  763.   persistTabAttribute: function sss_persistTabAttribute(aName) {
  764.     this.xulAttributes.push(aName);
  765.     this.saveStateDelayed();
  766.   },
  767.  
  768. /* ........ Saving Functionality .............. */
  769.  
  770.   /**
  771.    * Store all session data for a window
  772.    * @param aWindow
  773.    *        Window reference
  774.    */
  775.   _saveWindowHistory: function sss_saveWindowHistory(aWindow) {
  776.     var tabbrowser = aWindow.getBrowser();
  777.     var browsers = tabbrowser.browsers;
  778.     var tabs = this._windows[aWindow.__SSi].tabs = [];
  779.     this._windows[aWindow.__SSi].selected = 0;
  780.     
  781.     for (var i = 0; i < browsers.length; i++) {
  782.       var tabData = { entries: [], index: 0 };
  783.       
  784.       var browser = browsers[i];
  785.       if (!browser || !browser.currentURI) {
  786.         // can happen when calling this function right after .addTab()
  787.         tabs.push(tabData);
  788.         continue;
  789.       }
  790.       else if (browser.parentNode.__SS_data && browser.parentNode.__SS_data._tab) {
  791.         // use the data to be restored when the tab hasn't been completely
  792.         tabs.push(browser.parentNode.__SS_data);
  793.         continue;
  794.       }
  795.       var history = null;
  796.       
  797.       try {
  798.         history = browser.sessionHistory;
  799.       }
  800.       catch (ex) { } // this could happen if we catch a tab during (de)initialization
  801.       
  802.       if (history && browser.parentNode.__SS_data && browser.parentNode.__SS_data.entries[history.index]) {
  803.         tabData = browser.parentNode.__SS_data;
  804.         tabData.index = history.index + 1;
  805.       }
  806.       else if (history && history.count > 0) {
  807.         for (var j = 0; j < history.count; j++) {
  808.           tabData.entries.push(this._serializeHistoryEntry(history.getEntryAtIndex(j, false)));
  809.         }
  810.         tabData.index = history.index + 1;
  811.         
  812.         browser.parentNode.__SS_data = tabData;
  813.       }
  814.       else {
  815.         tabData.entries[0] = { url: browser.currentURI.spec };
  816.         tabData.index = 1;
  817.       }
  818.       tabData.zoom = browser.markupDocumentViewer.textZoom;
  819.       
  820.       var disallow = CAPABILITIES.filter(function(aCapability) {
  821.         return !browser.docShell["allow" + aCapability];
  822.       });
  823.       tabData.disallow = disallow.join(",");
  824.       
  825.       var _this = this;
  826.       var xulattr = Array.filter(tabbrowser.mTabs[i].attributes, function(aAttr) {
  827.         return (_this.xulAttributes.indexOf(aAttr.name) > -1);
  828.       }).map(function(aAttr) {
  829.         return aAttr.name + "=" + encodeURI(aAttr.value);
  830.       });
  831.       tabData.xultab = xulattr.join(" ");
  832.       
  833.       tabData.extData = tabbrowser.mTabs[i].__SS_extdata || null;
  834.       
  835.       tabs.push(tabData);
  836.       
  837.       if (browser == tabbrowser.selectedBrowser) {
  838.         this._windows[aWindow.__SSi].selected = i + 1;
  839.       }
  840.     }
  841.   },
  842.  
  843.   /**
  844.    * Get an object that is a serialized representation of a History entry
  845.    * Used for data storage
  846.    * @param aEntry
  847.    *        nsISHEntry instance
  848.    * @returns object
  849.    */
  850.   _serializeHistoryEntry: function sss_serializeHistoryEntry(aEntry) {
  851.     var entry = { url: aEntry.URI.spec, children: [] };
  852.     
  853.     if (aEntry.title && aEntry.title != entry.url) {
  854.       entry.title = aEntry.title;
  855.     }
  856.     if (aEntry.isSubFrame) {
  857.       entry.subframe = true;
  858.     }
  859.     if (!(aEntry instanceof Ci.nsISHEntry)) {
  860.       return entry;
  861.     }
  862.     
  863.     var cacheKey = aEntry.cacheKey;
  864.     if (cacheKey && cacheKey instanceof Ci.nsISupportsPRUint32) {
  865.       entry.cacheKey = cacheKey.data;
  866.     }
  867.     entry.ID = aEntry.ID;
  868.     
  869.     var x = {}, y = {};
  870.     aEntry.getScrollPosition(x, y);
  871.     entry.scroll = x.value + "," + y.value;
  872.     
  873.     try {
  874.       var prefPostdata = this._getPref("sessionstore.postdata", DEFAULT_POSTDATA);
  875.       if (prefPostdata && aEntry.postData && this._checkPrivacyLevel(aEntry.URI.schemeIs("https"))) {
  876.         aEntry.postData.QueryInterface(Ci.nsISeekableStream).
  877.                         seek(Ci.nsISeekableStream.NS_SEEK_SET, 0);
  878.         var stream = Cc["@mozilla.org/scriptableinputstream;1"].
  879.                      createInstance(Ci.nsIScriptableInputStream);
  880.         stream.init(aEntry.postData);
  881.         var postdata = stream.read(stream.available());
  882.         if (prefPostdata == -1 || postdata.replace(/^(Content-.*\r\n)+(\r\n)*/, "").length <= prefPostdata) {
  883.           entry.postdata = postdata;
  884.         }
  885.       }
  886.     }
  887.     catch (ex) { debug(ex); } // POSTDATA is tricky - especially since some extensions don't get it right
  888.  
  889.     var ownerURI =
  890.       (aEntry instanceof Ci.nsISHEntry_MOZILLA_1_8_BRANCH2) ?
  891.         aEntry.ownerURI : null;
  892.     if (ownerURI) {
  893.         entry.ownerURI = ownerURI.spec;
  894.     }
  895.     
  896.     if (!(aEntry instanceof Ci.nsISHContainer)) {
  897.       return entry;
  898.     }
  899.     
  900.     for (var i = 0; i < aEntry.childCount; i++) {
  901.       var child = aEntry.GetChildAt(i);
  902.       if (child) {
  903.         entry.children.push(this._serializeHistoryEntry(child));
  904.       }
  905.       else { // to maintain the correct frame order, insert a dummy entry 
  906.         entry.children.push({ url: "about:blank" });
  907.       }
  908.     }
  909.     
  910.     return entry;
  911.   },
  912.  
  913.   /**
  914.    * Updates the current document's cache of user entered text data
  915.    * @param aPanel
  916.    *        TabPanel reference
  917.    * @param aTextarea
  918.    *        HTML content element (without an XPCNativeWrapper applied)
  919.    * @returns bool
  920.    */
  921.   _saveTextData: function sss_saveTextData(aPanel, aTextarea) {
  922.     var wrappedTextarea = XPCNativeWrapper(aTextarea);
  923.     var id = wrappedTextarea.id ? "#" + wrappedTextarea.id :
  924.                                   wrappedTextarea.name;
  925.     if (!id
  926.       || !(wrappedTextarea instanceof Ci.nsIDOMHTMLTextAreaElement 
  927.       || wrappedTextarea instanceof Ci.nsIDOMHTMLInputElement)) {
  928.       return false; // nothing to save
  929.     }
  930.     
  931.     if (!aPanel.__SS_text) {
  932.       aPanel.__SS_text = [];
  933.       aPanel.__SS_text._refs = [];
  934.     }
  935.     
  936.     // get the index of the reference to the text element
  937.     var ix = aPanel.__SS_text._refs.indexOf(aTextarea);
  938.     if (ix == -1) {
  939.       // we haven't registered this text element yet - do so now
  940.       aPanel.__SS_text._refs.push(aTextarea);
  941.       ix = aPanel.__SS_text.length;
  942.     }
  943.     else if (!aPanel.__SS_text[ix].cache) {
  944.       // we've already marked this text element for saving (the cache is
  945.       // added during save operations and would have to be updated here)
  946.       return false;
  947.     }
  948.     
  949.     // determine the frame we're in and encode it into the textarea's ID
  950.     var content = wrappedTextarea.ownerDocument.defaultView;
  951.     while (content != content.top) {
  952.       var frames = content.parent.frames;
  953.       for (var i = 0; i < frames.length && frames[i] != content; i++);
  954.       id = i + "|" + id;
  955.       content = content.parent;
  956.     }
  957.     
  958.     // mark this element for saving
  959.     aPanel.__SS_text[ix] = { id: id, element: wrappedTextarea };
  960.     
  961.     return true;
  962.   },
  963.  
  964.   /**
  965.    * go through all frames and store the current scroll positions
  966.    * and innerHTML content of WYSIWYG editors
  967.    * @param aWindow
  968.    *        Window reference
  969.    */
  970.   _updateTextAndScrollData: function sss_updateTextAndScrollData(aWindow) {
  971.     var _this = this;
  972.     function updateRecursively(aContent, aData) {
  973.       for (var i = 0; i < aContent.frames.length; i++) {
  974.         if (aData.children && aData.children[i]) {
  975.           updateRecursively(aContent.frames[i], aData.children[i]);
  976.         }
  977.       }
  978.       // designMode is undefined e.g. for XUL documents (as about:config)
  979.       var isHTTPS = _this._getURIFromString((aContent.parent || aContent).
  980.                                         document.location.href).schemeIs("https");
  981.       if ((aContent.document.designMode || "") == "on" && _this._checkPrivacyLevel(isHTTPS)) {
  982.         if (aData.innerHTML == undefined) {
  983.           // we get no "input" events from iframes - listen for keypress here
  984.           aContent.addEventListener("keypress", function(aEvent) { _this.saveStateDelayed(aWindow, 3000); }, true);
  985.         }
  986.         aData.innerHTML = aContent.document.body.innerHTML;
  987.       }
  988.       aData.scroll = aContent.scrollX + "," + aContent.scrollY;
  989.     }
  990.     
  991.     Array.forEach(aWindow.getBrowser().browsers, function(aBrowser, aIx) {
  992.       try {
  993.         var tabData = this._windows[aWindow.__SSi].tabs[aIx];
  994.         if (tabData.entries.length == 0)
  995.           return; // ignore incompletely initialized tabs
  996.         
  997.         var text = [];
  998.         if (aBrowser.parentNode.__SS_text && this._checkPrivacyLevel(aBrowser.currentURI.schemeIs("https"))) {
  999.           for (var ix = aBrowser.parentNode.__SS_text.length - 1; ix >= 0; ix--) {
  1000.             var data = aBrowser.parentNode.__SS_text[ix];
  1001.             if (!data.cache) {
  1002.               // update the text element's value before adding it to the data structure
  1003.               data.cache = encodeURI(data.element.value);
  1004.             }
  1005.             text.push(data.id + "=" + data.cache);
  1006.           }
  1007.         }
  1008.         if (aBrowser.currentURI.spec == "about:config") {
  1009.           text = ["#textbox=" + encodeURI(aBrowser.contentDocument.getElementById("textbox").wrappedJSObject.value)];
  1010.         }
  1011.         tabData.text = text.join(" ");
  1012.         
  1013.         updateRecursively(XPCNativeWrapper(aBrowser.contentWindow), tabData.entries[tabData.index - 1]);
  1014.       }
  1015.       catch (ex) { debug(ex); } // get as much data as possible, ignore failures (might succeed the next time)
  1016.     }, this);
  1017.   },
  1018.  
  1019.   /**
  1020.    * store all hosts for a URL
  1021.    * @param aWindow
  1022.    *        Window reference
  1023.    */
  1024.   _updateCookieHosts: function sss_updateCookieHosts(aWindow) {
  1025.     var hosts = this._windows[aWindow.__SSi]._hosts = {};
  1026.     
  1027.     // get all possible subdomain levels for a given URL
  1028.     var _this = this;
  1029.     function extractHosts(aEntry) {
  1030.       if (/^https?:\/\/(?:[^@\/\s]+@)?([\w.-]+)/.test(aEntry.url) &&
  1031.         !hosts[RegExp.$1] && _this._checkPrivacyLevel(_this._getURIFromString(aEntry.url).schemeIs("https"))) {
  1032.         var host = RegExp.$1;
  1033.         var ix;
  1034.         for (ix = host.indexOf(".") + 1; ix; ix = host.indexOf(".", ix) + 1) {
  1035.           hosts[host.substr(ix)] = true;
  1036.         }
  1037.         hosts[host] = true;
  1038.       }
  1039.       if (aEntry.children) {
  1040.         aEntry.children.forEach(extractHosts);
  1041.       }
  1042.     }
  1043.     
  1044.     this._windows[aWindow.__SSi].tabs.forEach(function(aTabData) { aTabData.entries.forEach(extractHosts); });
  1045.   },
  1046.  
  1047.   /**
  1048.    * Serialize cookie data
  1049.    * @param aWindows
  1050.    *        array of Window references
  1051.    */
  1052.   _updateCookies: function sss_updateCookies(aWindows) {
  1053.     var cookiesEnum = Cc["@mozilla.org/cookiemanager;1"].
  1054.                       getService(Ci.nsICookieManager).enumerator;
  1055.     // collect the cookies per window
  1056.     for (var i = 0; i < aWindows.length; i++) {
  1057.       aWindows[i].cookies = { count: 0 };
  1058.     }
  1059.     
  1060.     var _this = this;
  1061.     while (cookiesEnum.hasMoreElements()) {
  1062.       var cookie = cookiesEnum.getNext().QueryInterface(Ci.nsICookie2);
  1063.       if (cookie.isSession && cookie.host) {
  1064.         var url = "", value = "";
  1065.         aWindows.forEach(function(aWindow) {
  1066.           if (aWindow._hosts && aWindow._hosts[cookie.rawHost]) {
  1067.             // make sure to construct URL and value only once per cookie
  1068.             if (!url) {
  1069.               var url = "http" + (cookie.isSecure ? "s" : "") + "://" + cookie.host + (cookie.path || "").replace(/^(?!\/)/, "/");
  1070.               if (_this._checkPrivacyLevel(cookie.isSecure)) {
  1071.                 value = (cookie.name || "name") + "=" + (cookie.value || "") + ";";
  1072.                 value += cookie.isDomain ? "domain=" + cookie.rawHost + ";" : "";
  1073.                 value += cookie.path ? "path=" + cookie.path + ";" : "";
  1074.                 value += cookie.isSecure ? "secure;" : "";
  1075.                 value += cookie.isHttpOnly ? "httponly;" : "";
  1076.               }
  1077.             }
  1078.             if (value) {
  1079.               // in order to not unnecessarily bloat the session file,
  1080.               // all window cookies are saved into one JS object
  1081.               var cookies = aWindow.cookies;
  1082.               cookies["domain" + ++cookies.count] = url;
  1083.               cookies["value" + cookies.count] = value;
  1084.             }
  1085.           }
  1086.         });
  1087.       }
  1088.     }
  1089.     
  1090.     // don't include empty cookie sections
  1091.     for (i = 0; i < aWindows.length; i++) {
  1092.       if (aWindows[i].cookies.count == 0) {
  1093.         delete aWindows[i].cookies;
  1094.       }
  1095.     }
  1096.   },
  1097.  
  1098.   /**
  1099.    * Store window dimensions, visibility, sidebar
  1100.    * @param aWindow
  1101.    *        Window reference
  1102.    */
  1103.   _updateWindowFeatures: function sss_updateWindowFeatures(aWindow) {
  1104.     var winData = this._windows[aWindow.__SSi];
  1105.     
  1106.     WINDOW_ATTRIBUTES.forEach(function(aAttr) {
  1107.       winData[aAttr] = this._getWindowDimension(aWindow, aAttr);
  1108.     }, this);
  1109.     
  1110.     winData.hidden = WINDOW_HIDEABLE_FEATURES.filter(function(aItem) {
  1111.       return aWindow[aItem] && !aWindow[aItem].visible;
  1112.     }).join(",");
  1113.     
  1114.     winData.sidebar = aWindow.document.getElementById("sidebar-box").getAttribute("sidebarcommand");
  1115.   },
  1116.  
  1117.   /**
  1118.    * serialize session data as Ini-formatted string
  1119.    * @returns string
  1120.    */
  1121.   _getCurrentState: function sss_getCurrentState() {
  1122.     var activeWindow = this._getMostRecentBrowserWindow();
  1123.     
  1124.     if (this._loadState == STATE_RUNNING) {
  1125.       // update the data for all windows with activities since the last save operation
  1126.       this._forEachBrowserWindow(function(aWindow) {
  1127.         if (this._dirty || this._dirtyWindows[aWindow.__SSi] || aWindow == activeWindow) {
  1128.           this._collectWindowData(aWindow);
  1129.         }
  1130.         else { // always update the window features (whose change alone never triggers a save operation)
  1131.           this._updateWindowFeatures(aWindow);
  1132.         }
  1133.       }, this);
  1134.       this._dirtyWindows = [];
  1135.       this._dirty = false;
  1136.     }
  1137.     
  1138.     // collect the data for all windows
  1139.     var total = [], windows = [];
  1140.     var ix;
  1141.     for (ix in this._windows) {
  1142.       total.push(this._windows[ix]);
  1143.       windows.push(ix);
  1144.     }
  1145.     this._updateCookies(total);
  1146.     
  1147.     // make sure that the current window is restored first
  1148.     var ix = activeWindow ? windows.indexOf(activeWindow.__SSi || "") : -1;
  1149.     if (ix > 0) {
  1150.       total.unshift(total.splice(ix, 1)[0]);
  1151.     }
  1152.  
  1153.     // if no browser window remains open, return the state of the last closed window
  1154.     if (total.length == 0 && this._lastWindowClosed) {
  1155.       total.push(this._lastWindowClosed);
  1156.     }
  1157.     
  1158.     return { windows: total };
  1159.   },
  1160.  
  1161.   /**
  1162.    * serialize session data for a window 
  1163.    * @param aWindow
  1164.    *        Window reference
  1165.    * @returns string
  1166.    */
  1167.   _getWindowState: function sss_getWindowState(aWindow) {
  1168.     if (this._loadState == STATE_RUNNING) {
  1169.       this._collectWindowData(aWindow);
  1170.     }
  1171.     
  1172.     var total = [this._windows[aWindow.__SSi]];
  1173.     this._updateCookies(total);
  1174.     
  1175.     return { windows: total };
  1176.   },
  1177.  
  1178.   _collectWindowData: function sss_collectWindowData(aWindow) {
  1179.     // update the internal state data for this window
  1180.     this._saveWindowHistory(aWindow);
  1181.     this._updateTextAndScrollData(aWindow);
  1182.     this._updateCookieHosts(aWindow);
  1183.     this._updateWindowFeatures(aWindow);
  1184.     
  1185.     this._dirtyWindows[aWindow.__SSi] = false;
  1186.   },
  1187.  
  1188. /* ........ Restoring Functionality .............. */
  1189.  
  1190.   /**
  1191.    * restore features to a single window
  1192.    * @param aWindow
  1193.    *        Window reference
  1194.    * @param aState
  1195.    *        JS object or its eval'able source
  1196.    * @param aOverwriteTabs
  1197.    *        bool overwrite existing tabs w/ new ones
  1198.    */
  1199.   restoreWindow: function sss_restoreWindow(aWindow, aState, aOverwriteTabs) {
  1200.     // initialize window if necessary
  1201.     if (aWindow && (!aWindow.__SSi || !this._windows[aWindow.__SSi]))
  1202.       this.onLoad(aWindow);
  1203.  
  1204.     try {
  1205.       var root = typeof aState == "string" ? this._safeEval(aState) : aState;
  1206.       if (!root.windows[0]) {
  1207.         return; // nothing to restore
  1208.       }
  1209.     }
  1210.     catch (ex) { // invalid state object - don't restore anything 
  1211.       debug(ex);
  1212.       return;
  1213.     }
  1214.     
  1215.     var winData;
  1216.     // open new windows for all further window entries of a multi-window session
  1217.     // (unless they don't contain any tab data)
  1218.     for (var w = 1; w < root.windows.length; w++) {
  1219.       winData = root.windows[w];
  1220.       if (winData && winData.tabs && winData.tabs[0]) {
  1221.         this._openWindowWithState({ windows: [winData], opener: aWindow });
  1222.       }
  1223.     }
  1224.     
  1225.     winData = root.windows[0];
  1226.     if (!winData.tabs) {
  1227.       winData.tabs = [];
  1228.     }
  1229.     
  1230.     var tabbrowser = aWindow.getBrowser();
  1231.     var openTabCount = aOverwriteTabs ? tabbrowser.browsers.length : -1;
  1232.     var newTabCount = winData.tabs.length;
  1233.     
  1234.     for (var t = 0; t < newTabCount; t++) {
  1235.       winData.tabs[t]._tab = t < openTabCount ? tabbrowser.mTabs[t] : tabbrowser.addTab();
  1236.       // when resuming at startup: add additionally requested pages to the end
  1237.       if (!aOverwriteTabs && root._firstTabs) {
  1238.         tabbrowser.moveTabTo(winData.tabs[t]._tab, t);
  1239.       }
  1240.     }
  1241.  
  1242.     // when overwriting tabs, remove all superflous ones
  1243.     for (t = openTabCount - 1; t >= newTabCount; t--) {
  1244.       tabbrowser.removeTab(tabbrowser.mTabs[t]);
  1245.     }
  1246.     
  1247.     if (aOverwriteTabs) {
  1248.       this.restoreWindowFeatures(aWindow, winData, root.opener || null);
  1249.     }
  1250.     if (winData.cookies) {
  1251.       this.restoreCookies(winData.cookies);
  1252.     }
  1253.     if (winData.extData) {
  1254.       if (!this._windows[aWindow.__SSi].extData) {
  1255.         this._windows[aWindow.__SSi].extData = {}
  1256.       }
  1257.       for (var key in winData.extData) {
  1258.         this._windows[aWindow.__SSi].extData[key] = winData.extData[key];
  1259.       }
  1260.     }
  1261.     if (winData._closedTabs && (root._firstTabs || aOverwriteTabs)) {
  1262.       //XXXzeniko remove the slice call as soon as _closedTabs instanceof Array
  1263.       this._windows[aWindow.__SSi]._closedTabs = winData._closedTabs.slice();
  1264.     }
  1265.     
  1266.     this.restoreHistoryPrecursor(aWindow, winData.tabs, (aOverwriteTabs ?
  1267.       (parseInt(winData.selected) || 1) : 0), 0, 0);
  1268.   },
  1269.  
  1270.   /**
  1271.    * Manage history restoration for a window
  1272.    * @param aTabs
  1273.    *        Array of tab data
  1274.    * @param aCurrentTabs
  1275.    *        Array of tab references
  1276.    * @param aSelectTab
  1277.    *        Index of selected tab
  1278.    * @param aCount
  1279.    *        Counter for number of times delaying b/c browser or history aren't ready
  1280.    */
  1281.   restoreHistoryPrecursor: function sss_restoreHistoryPrecursor(aWindow, aTabs, aSelectTab, aIx, aCount) {
  1282.     var tabbrowser = aWindow.getBrowser();
  1283.     
  1284.     // make sure that all browsers and their histories are available
  1285.     // - if one's not, resume this check in 100ms (repeat at most 10 times)
  1286.     for (var t = aIx; t < aTabs.length; t++) {
  1287.       try {
  1288.         if (!tabbrowser.getBrowserForTab(aTabs[t]._tab).webNavigation.sessionHistory) {
  1289.           throw new Error();
  1290.         }
  1291.       }
  1292.       catch (ex) { // in case browser or history aren't ready yet 
  1293.         if (aCount < 10) {
  1294.           var restoreHistoryFunc = function(self) {
  1295.             self.restoreHistoryPrecursor(aWindow, aTabs, aSelectTab, aIx, aCount + 1);
  1296.           }
  1297.           aWindow.setTimeout(restoreHistoryFunc, 100, this);
  1298.           return;
  1299.         }
  1300.       }
  1301.     }
  1302.     
  1303.     // mark the tabs as loading
  1304.     for (t = 0; t < aTabs.length; t++) {
  1305.       if (!aTabs[t].entries || !aTabs[t].entries[0])
  1306.         continue; // there won't be anything to load
  1307.       
  1308.       var tab = aTabs[t]._tab;
  1309.       var browser = tabbrowser.getBrowserForTab(tab);
  1310.       browser.stop(); // in case about:blank isn't done yet
  1311.       
  1312.       tab.setAttribute("busy", "true");
  1313.       tabbrowser.updateIcon(tab);
  1314.       tabbrowser.setTabTitleLoading(tab);
  1315.       
  1316.       // keep the data around to prevent dataloss in case
  1317.       // a tab gets closed before it's been properly restored
  1318.       browser.parentNode.__SS_data = aTabs[t];
  1319.     }
  1320.     
  1321.     // make sure to restore the selected tab first (if any)
  1322.     if (aSelectTab-- && aTabs[aSelectTab]) {
  1323.         aTabs.unshift(aTabs.splice(aSelectTab, 1)[0]);
  1324.         tabbrowser.selectedTab = aTabs[0]._tab;
  1325.     }
  1326.     
  1327.     this.restoreHistory(aWindow, aTabs);
  1328.   },
  1329.  
  1330.   /**
  1331.    * Restory history for a window
  1332.    * @param aWindow
  1333.    *        Window reference
  1334.    * @param aTabs
  1335.    *        Array of tab data
  1336.    * @param aCurrentTabs
  1337.    *        Array of tab references
  1338.    * @param aSelectTab
  1339.    *        Index of selected tab
  1340.    */
  1341.   restoreHistory: function sss_restoreHistory(aWindow, aTabs, aIdMap) {
  1342.     var _this = this;
  1343.     while (aTabs.length > 0 && (!aTabs[0]._tab || !aTabs[0]._tab.parentNode)) {
  1344.       aTabs.shift(); // this tab got removed before being completely restored
  1345.     }
  1346.     if (aTabs.length == 0) {
  1347.       return; // no more tabs to restore
  1348.     }
  1349.     
  1350.     var tabData = aTabs.shift();
  1351.  
  1352.     // helper hash for ensuring unique frame IDs
  1353.     var idMap = { used: {} };
  1354.     
  1355.     var tab = tabData._tab;
  1356.     var browser = aWindow.getBrowser().getBrowserForTab(tab);
  1357.     var history = browser.webNavigation.sessionHistory;
  1358.     
  1359.     if (history.count > 0) {
  1360.       history.PurgeHistory(history.count);
  1361.     }
  1362.     history.QueryInterface(Ci.nsISHistoryInternal);
  1363.     
  1364.     if (!tabData.entries) {
  1365.       tabData.entries = [];
  1366.     }
  1367.     if (tabData.extData) {
  1368.       tab.__SS_extdata = tabData.extData;
  1369.     }
  1370.     
  1371.     browser.markupDocumentViewer.textZoom = parseFloat(tabData.zoom || 1);
  1372.     
  1373.     for (var i = 0; i < tabData.entries.length; i++) {
  1374.       history.addEntry(this._deserializeHistoryEntry(tabData.entries[i], idMap), true);
  1375.     }
  1376.     
  1377.     // make sure to reset the capabilities and attributes, in case this tab gets reused
  1378.     var disallow = (tabData.disallow)?tabData.disallow.split(","):[];
  1379.     CAPABILITIES.forEach(function(aCapability) {
  1380.       browser.docShell["allow" + aCapability] = disallow.indexOf(aCapability) == -1;
  1381.     });
  1382.     Array.filter(tab.attributes, function(aAttr) {
  1383.       return (_this.xulAttributes.indexOf(aAttr.name) > -1);
  1384.     }).forEach(tab.removeAttribute, tab);
  1385.     if (tabData.xultab) {
  1386.       tabData.xultab.split(" ").forEach(function(aAttr) {
  1387.         if (/^([^\s=]+)=(.*)/.test(aAttr)) {
  1388.           tab.setAttribute(RegExp.$1, decodeURI(RegExp.$2));
  1389.         }
  1390.       });
  1391.     }
  1392.     
  1393.     // notify the tabbrowser that the tab chrome has been restored
  1394.     var event = aWindow.document.createEvent("Events");
  1395.     event.initEvent("SSTabRestoring", true, false);
  1396.     tab.dispatchEvent(event);
  1397.     
  1398.     var activeIndex = (tabData.index || tabData.entries.length) - 1;
  1399.     try {
  1400.       browser.webNavigation.gotoIndex(activeIndex);
  1401.     }
  1402.     catch (ex) { } // ignore an invalid tabData.index
  1403.     
  1404.     // restore those aspects of the currently active documents
  1405.     // which are not preserved in the plain history entries
  1406.     // (mainly scroll state and text data)
  1407.     browser.__SS_restore_data = tabData.entries[activeIndex] || {};
  1408.     browser.__SS_restore_text = tabData.text || "";
  1409.     browser.__SS_restore_tab = tab;
  1410.     browser.__SS_restore = this.restoreDocument_proxy;
  1411.     browser.addEventListener("load", browser.__SS_restore, true);
  1412.     
  1413.     aWindow.setTimeout(function(){ _this.restoreHistory(aWindow, aTabs, aIdMap); }, 0);
  1414.   },
  1415.  
  1416.   /**
  1417.    * expands serialized history data into a session-history-entry instance
  1418.    * @param aEntry
  1419.    *        Object containing serialized history data for a URL
  1420.    * @param aIdMap
  1421.    *        Hash for ensuring unique frame IDs
  1422.    * @returns nsISHEntry
  1423.    */
  1424.   _deserializeHistoryEntry: function sss_deserializeHistoryEntry(aEntry, aIdMap) {
  1425.     var shEntry = Cc["@mozilla.org/browser/session-history-entry;1"].
  1426.                   createInstance(Ci.nsISHEntry_MOZILLA_1_8_BRANCH2);
  1427.     
  1428.     var ioService = Cc["@mozilla.org/network/io-service;1"].
  1429.                     getService(Ci.nsIIOService);
  1430.     shEntry.setURI(ioService.newURI(aEntry.url, null, null));
  1431.     shEntry.setTitle(aEntry.title || aEntry.url);
  1432.     shEntry.setIsSubFrame(aEntry.subframe || false);
  1433.     shEntry.loadType = Ci.nsIDocShellLoadInfo.loadHistory;
  1434.     
  1435.     if (aEntry.cacheKey) {
  1436.       var cacheKey = Cc["@mozilla.org/supports-PRUint32;1"].
  1437.                      createInstance(Ci.nsISupportsPRUint32);
  1438.       cacheKey.data = aEntry.cacheKey;
  1439.       shEntry.cacheKey = cacheKey;
  1440.     }
  1441.     if (aEntry.ID) {
  1442.       // get a new unique ID for this frame (since the one from the last
  1443.       // start might already be in use)
  1444.       var id = aIdMap[aEntry.ID] || 0;
  1445.       if (!id) {
  1446.         for (id = Date.now(); aIdMap.used[id]; id++);
  1447.         aIdMap[aEntry.ID] = id;
  1448.         aIdMap.used[id] = true;
  1449.       }
  1450.       shEntry.ID = id;
  1451.     }
  1452.     
  1453.     var scrollPos = (aEntry.scroll || "0,0").split(",");
  1454.     scrollPos = [parseInt(scrollPos[0]) || 0, parseInt(scrollPos[1]) || 0];
  1455.     shEntry.setScrollPosition(scrollPos[0], scrollPos[1]);
  1456.     
  1457.     if (aEntry.postdata) {
  1458.       var stream = Cc["@mozilla.org/io/string-input-stream;1"].
  1459.                    createInstance(Ci.nsIStringInputStream);
  1460.       stream.setData(aEntry.postdata, -1);
  1461.       shEntry.postData = stream;
  1462.     }
  1463.  
  1464.     if (aEntry.ownerURI) {
  1465.         shEntry.ownerURI = ioService.newURI(aEntry.ownerURI, null, null);
  1466.     }
  1467.     
  1468.     if (aEntry.children && shEntry instanceof Ci.nsISHContainer) {
  1469.       for (var i = 0; i < aEntry.children.length; i++) {
  1470.         shEntry.AddChild(this._deserializeHistoryEntry(aEntry.children[i], aIdMap), i);
  1471.       }
  1472.     }
  1473.     
  1474.     return shEntry;
  1475.   },
  1476.  
  1477.   /**
  1478.    * Restore properties to a loaded document
  1479.    */
  1480.   restoreDocument_proxy: function sss_restoreDocument_proxy(aEvent) {
  1481.     // wait for the top frame to be loaded completely
  1482.     if (!aEvent || !aEvent.originalTarget || !aEvent.originalTarget.defaultView || aEvent.originalTarget.defaultView != aEvent.originalTarget.defaultView.top) {
  1483.       return;
  1484.     }
  1485.     
  1486.     var textArray = this.__SS_restore_text ? this.__SS_restore_text.split(" ") : [];
  1487.     function restoreTextData(aContent, aPrefix) {
  1488.       textArray.forEach(function(aEntry) {
  1489.         if (/^((?:\d+\|)*)(#?)([^\s=]+)=(.*)$/.test(aEntry) && (!RegExp.$1 || RegExp.$1 == aPrefix)) {
  1490.           var document = aContent.document;
  1491.           var node = RegExp.$2 ? document.getElementById(RegExp.$3) : document.getElementsByName(RegExp.$3)[0] || null;
  1492.           if (node && "value" in node) {
  1493.             node.value = decodeURI(RegExp.$4);
  1494.             
  1495.             var event = document.createEvent("UIEvents");
  1496.             event.initUIEvent("input", true, true, aContent, 0);
  1497.             node.dispatchEvent(event);
  1498.           }
  1499.         }
  1500.       });
  1501.     }
  1502.     
  1503.     function restoreTextDataAndScrolling(aContent, aData, aPrefix) {
  1504.       restoreTextData(aContent, aPrefix);
  1505.       if (aData.innerHTML) {
  1506.         aContent.setTimeout(function(aHTML) { if (this.document.designMode == "on") { this.document.body.innerHTML = aHTML; } }, 0, aData.innerHTML);
  1507.       }
  1508.       if (aData.scroll && /(\d+),(\d+)/.test(aData.scroll)) {
  1509.         aContent.scrollTo(RegExp.$1, RegExp.$2);
  1510.       }
  1511.       for (var i = 0; i < aContent.frames.length; i++) {
  1512.         if (aData.children && aData.children[i]) {
  1513.           restoreTextDataAndScrolling(aContent.frames[i], aData.children[i], i + "|" + aPrefix);
  1514.         }
  1515.       }
  1516.     }
  1517.     
  1518.     var content = XPCNativeWrapper(aEvent.originalTarget).defaultView;
  1519.     if (this.currentURI.spec == "about:config") {
  1520.       // unwrap the document for about:config because otherwise the properties
  1521.       // of the XBL bindings - as the textbox - aren't accessible (see bug 350718)
  1522.       content = content.wrappedJSObject;
  1523.     }
  1524.     restoreTextDataAndScrolling(content, this.__SS_restore_data, "");
  1525.     
  1526.     // notify the tabbrowser that this document has been completely restored
  1527.     var event = this.ownerDocument.createEvent("Events");
  1528.     event.initEvent("SSTabRestored", true, false);
  1529.     this.__SS_restore_tab.dispatchEvent(event);
  1530.     
  1531.     this.removeEventListener("load", this.__SS_restore, true);
  1532.     delete this.__SS_restore_data;
  1533.     delete this.__SS_restore_text;
  1534.     delete this.__SS_restore_tab;
  1535.     delete this.__SS_restore;
  1536.   },
  1537.  
  1538.   /**
  1539.    * Restore visibility and dimension features to a window
  1540.    * @param aWindow
  1541.    *        Window reference
  1542.    * @param aWinData
  1543.    *        Object containing session data for the window
  1544.    * @param aOpener
  1545.    *        Opening window, for refocusing
  1546.    */
  1547.   restoreWindowFeatures: function sss_restoreWindowFeatures(aWindow, aWinData, aOpener) {
  1548.     var hidden = (aWinData.hidden)?aWinData.hidden.split(","):[];
  1549.     WINDOW_HIDEABLE_FEATURES.forEach(function(aItem) {
  1550.       aWindow[aItem].visible = hidden.indexOf(aItem) == -1;
  1551.     });
  1552.     
  1553.     var _this = this;
  1554.     aWindow.setTimeout(function() {
  1555.       _this.restoreDimensions_proxy.apply(_this, [aWindow, aOpener, aWinData.width || 0, 
  1556.         aWinData.height || 0, "screenX" in aWinData ? aWinData.screenX : NaN,
  1557.         "screenY" in aWinData ? aWinData.screenY : NaN,
  1558.         aWinData.sizemode || "", aWinData.sidebar || ""]);
  1559.     }, 0);
  1560.   },
  1561.  
  1562.   /**
  1563.    * Restore a window's dimensions
  1564.    * @param aOpener
  1565.    *        Opening window, for refocusing
  1566.    * @param aWidth
  1567.    *        Window width
  1568.    * @param aHeight
  1569.    *        Window height
  1570.    * @param aLeft
  1571.    *        Window left
  1572.    * @param aTop
  1573.    *        Window top
  1574.    * @param aSizeMode
  1575.    *        Window size mode (eg: maximized)
  1576.    * @param aSidebar
  1577.    *        Sidebar command
  1578.    */
  1579.   restoreDimensions_proxy: function sss_restoreDimensions_proxy(aWindow, aOpener, aWidth, aHeight, aLeft, aTop, aSizeMode, aSidebar) {
  1580.     var win = aWindow;
  1581.     var _this = this;
  1582.     function win_(aName) { return _this._getWindowDimension(win, aName); }
  1583.     
  1584.     // only modify those aspects which aren't correct yet
  1585.     if (aWidth && aHeight && (aWidth != win_("width") || aHeight != win_("height"))) {
  1586.       aWindow.resizeTo(aWidth, aHeight);
  1587.     }
  1588.     if (!isNaN(aLeft) && !isNaN(aTop) && (aLeft != win_("screenX") || aTop != win_("screenY"))) {
  1589.       aWindow.moveTo(aLeft, aTop);
  1590.     }
  1591.     if (aSizeMode == "maximized" && win_("sizemode") != "maximized") {
  1592.       aWindow.maximize();
  1593.     }
  1594.     else if (aSizeMode && aSizeMode != "maximized" && win_("sizemode") != "normal") {
  1595.       aWindow.restore();
  1596.     }
  1597.     var sidebar = aWindow.document.getElementById("sidebar-box");
  1598.     if (sidebar.getAttribute("sidebarcommand") != aSidebar) {
  1599.       aWindow.toggleSidebar(aSidebar);
  1600.     }
  1601.     // since resizing/moving a window brings it to the foreground,
  1602.     // we might want to re-focus the window which created this one
  1603.     if (aOpener) {
  1604.       aOpener.focus();
  1605.     }
  1606.   },
  1607.  
  1608.   /**
  1609.    * Restores cookies to cookie service
  1610.    * @param aCookies
  1611.    *        Array of cookie data
  1612.    */
  1613.   restoreCookies: function sss_restoreCookies(aCookies) {
  1614.     var cookieService = Cc["@mozilla.org/cookieService;1"].
  1615.                         getService(Ci.nsICookieService);
  1616.     var ioService = Cc["@mozilla.org/network/io-service;1"].
  1617.                     getService(Ci.nsIIOService);
  1618.     
  1619.     for (var i = 1; i <= aCookies.count; i++) {
  1620.       try {
  1621.         cookieService.setCookieStringFromHttp(ioService.newURI(aCookies["domain" + i], null, null), null, null, aCookies["value" + i] + "expires=0", null, null);
  1622.       }
  1623.       catch (ex) { debug(ex); } // don't let a single cookie stop recovering (might happen if a user tried to edit the session file)
  1624.     }
  1625.   },
  1626.  
  1627.   /**
  1628.    * Restart incomplete downloads
  1629.    * @param aWindow
  1630.    *        Window reference
  1631.    */
  1632.   retryDownloads: function sss_retryDownloads(aWindow) {
  1633.     var downloadManager = Cc["@mozilla.org/download-manager;1"].
  1634.                           getService(Ci.nsIDownloadManager);
  1635.     var rdfService = Cc["@mozilla.org/rdf/rdf-service;1"].
  1636.                      getService(Ci.nsIRDFService);
  1637.     var ioService = Cc["@mozilla.org/network/io-service;1"].
  1638.                     getService(Ci.nsIIOService);
  1639.     
  1640.     var rdfContainer = Cc["@mozilla.org/rdf/container;1"].
  1641.                        createInstance(Ci.nsIRDFContainer);
  1642.     var datasource = downloadManager.datasource;
  1643.     
  1644.     try {
  1645.       rdfContainer.Init(datasource, rdfService.GetResource("NC:DownloadsRoot"));
  1646.     }
  1647.     catch (ex) { // missing downloads datasource
  1648.       return;
  1649.     }
  1650.     
  1651.     // iterate through all downloads currently available in the RDF store
  1652.     // and restart the ones which were in progress before the crash
  1653.     var downloads = rdfContainer.GetElements();
  1654.     while (downloads.hasMoreElements()) {
  1655.       var download = downloads.getNext().QueryInterface(Ci.nsIRDFResource);
  1656.  
  1657.       // restart only if the download's in progress
  1658.       var node = datasource.GetTarget(download, rdfService.GetResource("http://home.netscape.com/NC-rdf#DownloadState"), true);
  1659.       if (node) {
  1660.         node.QueryInterface(Ci.nsIRDFInt);
  1661.       }
  1662.       if (!node || node.Value != Ci.nsIDownloadManager.DOWNLOAD_DOWNLOADING) {
  1663.         continue;
  1664.       }
  1665.  
  1666.       // URL being downloaded
  1667.       node = datasource.GetTarget(download, rdfService.GetResource("http://home.netscape.com/NC-rdf#URL"), true);
  1668.       var url = node.QueryInterface(Ci.nsIRDFResource).Value;
  1669.       
  1670.       // location where download's being saved
  1671.       node = datasource.GetTarget(download, rdfService.GetResource("http://home.netscape.com/NC-rdf#File"), true);
  1672.  
  1673.       // nsIRDFResource.Value is a string that's a URI; the downloads.rdf from
  1674.       // which this was created will have a string in one of the following two
  1675.       // forms, depending on platform:
  1676.       //
  1677.       //    /home/lumpy/dogtreat.txt
  1678.       //    C:\lumpy\dogtreat.txt
  1679.       //
  1680.       // During RDF loading, the string *appears* to be converted to a URL if
  1681.       // necessary.  Strings in the first form are not URLs and are converted to
  1682.       // file: URLs; strings in the latter form seem to be treated as if they
  1683.       // already are URLs and thus are not modified.  Consequently, on platforms
  1684.       // where paths aren't URLs, we need to extract the path from the file:
  1685.       // URL.
  1686.       //
  1687.       // See also bug 335725, bug 239948, and bug 349971.
  1688.       var savedTo = node.QueryInterface(Ci.nsIRDFResource).Value;
  1689.       try {
  1690.         var savedToURI = Cc["@mozilla.org/network/io-service;1"].
  1691.                          getService(Ci.nsIIOService).
  1692.                          newURI(savedTo, null, null);
  1693.         if (savedToURI.schemeIs("file"))
  1694.           savedTo = savedToURI.path;
  1695.       }
  1696.       catch (e) { /* not a URI, assume it was a string of form #1 */ }
  1697.  
  1698.       var linkChecker = Cc["@mozilla.org/network/urichecker;1"].
  1699.                         createInstance(Ci.nsIURIChecker);
  1700.       linkChecker.init(ioService.newURI(url, null, null));
  1701.       linkChecker.loadFlags = Ci.nsIRequest.LOAD_BACKGROUND;
  1702.       linkChecker.asyncCheck(new AutoDownloader(url, savedTo, aWindow), null);
  1703.     }
  1704.   },
  1705.  
  1706. /* ........ Disk Access .............. */
  1707.  
  1708.   /**
  1709.    * save state delayed by N ms
  1710.    * marks window as dirty (i.e. data update can't be skipped)
  1711.    * @param aWindow
  1712.    *        Window reference
  1713.    * @param aDelay
  1714.    *        Milliseconds to delay
  1715.    */
  1716.   saveStateDelayed: function sss_saveStateDelayed(aWindow, aDelay) {
  1717.     if (aWindow) {
  1718.       this._dirtyWindows[aWindow.__SSi] = true;
  1719.     }
  1720.  
  1721.     if (!this._saveTimer && this._resume_from_crash) {
  1722.       // interval until the next disk operation is allowed
  1723.       var minimalDelay = this._lastSaveTime + this._interval - Date.now();
  1724.       
  1725.       // if we have to wait, set a timer, otherwise saveState directly
  1726.       aDelay = Math.max(minimalDelay, aDelay || 2000);
  1727.       if (aDelay > 0) {
  1728.         this._saveTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
  1729.         this._saveTimer.init(this, aDelay, Ci.nsITimer.TYPE_ONE_SHOT);
  1730.       }
  1731.       else {
  1732.         this.saveState();
  1733.       }
  1734.     }
  1735.   },
  1736.  
  1737.   /**
  1738.    * save state to disk
  1739.    * @param aUpdateAll
  1740.    *        Bool update all windows 
  1741.    */
  1742.   saveState: function sss_saveState(aUpdateAll) {
  1743.     // if crash recovery is disabled, only save session resuming information
  1744.     if (!this._resume_from_crash && this._loadState == STATE_RUNNING)
  1745.       return;
  1746.     
  1747.     this._dirty = aUpdateAll;
  1748.     var oState = this._getCurrentState();
  1749.     oState.session = { state: ((this._loadState == STATE_RUNNING) ? STATE_RUNNING_STR : STATE_STOPPED_STR) };
  1750.     this._writeFile(this._sessionFile, oState.toSource());
  1751.     this._lastSaveTime = Date.now();
  1752.   },
  1753.  
  1754.   /**
  1755.    * delete session datafile and backup
  1756.    */
  1757.   _clearDisk: function sss_clearDisk() {
  1758.     if (this._sessionFile.exists()) {
  1759.       try {
  1760.         this._sessionFile.remove(false);
  1761.       }
  1762.       catch (ex) { dump(ex + '\n'); } // couldn't remove the file - what now?
  1763.     }
  1764.     if (this._sessionFileBackup.exists()) {
  1765.       try {
  1766.         this._sessionFileBackup.remove(false);
  1767.       }
  1768.       catch (ex) { dump(ex + '\n'); } // couldn't remove the file - what now?
  1769.     }
  1770.   },
  1771.  
  1772. /* ........ Auxiliary Functions .............. */
  1773.  
  1774.   /**
  1775.    * call a callback for all currently opened browser windows
  1776.    * (might miss the most recent one)
  1777.    * @param aFunc
  1778.    *        Callback each window is passed to
  1779.    */
  1780.   _forEachBrowserWindow: function sss_forEachBrowserWindow(aFunc) {
  1781.     var windowMediator = Cc["@mozilla.org/appshell/window-mediator;1"].
  1782.                          getService(Ci.nsIWindowMediator);
  1783.     var windowsEnum = windowMediator.getEnumerator("navigator:browser");
  1784.     
  1785.     while (windowsEnum.hasMoreElements()) {
  1786.       var window = windowsEnum.getNext();
  1787.       if (window.__SSi) {
  1788.         aFunc.call(this, window);
  1789.       }
  1790.     }
  1791.   },
  1792.  
  1793.   /**
  1794.    * Returns most recent window
  1795.    * @returns Window reference
  1796.    */
  1797.   _getMostRecentBrowserWindow: function sss_getMostRecentBrowserWindow() {
  1798.     var windowMediator = Cc["@mozilla.org/appshell/window-mediator;1"].
  1799.                          getService(Ci.nsIWindowMediator);
  1800.     return windowMediator.getMostRecentWindow("navigator:browser");
  1801.   },
  1802.  
  1803.   /**
  1804.    * open a new browser window for a given session state
  1805.    * called when restoring a multi-window session
  1806.    * @param aState
  1807.    *        Object containing session data
  1808.    */
  1809.   _openWindowWithState: function sss_openWindowWithState(aState) {
  1810.     
  1811.     var argString = Cc["@mozilla.org/supports-string;1"].
  1812.                     createInstance(Ci.nsISupportsString);
  1813.     argString.data = "";
  1814.  
  1815.     //XXXzeniko shouldn't it be possible to set the window's dimensions here (as feature)?
  1816.     var window = Cc["@mozilla.org/embedcomp/window-watcher;1"].
  1817.                  getService(Ci.nsIWindowWatcher).
  1818.                  openWindow(null, this._getPref("chromeURL", null), "_blank", "chrome,dialog=no,all", argString);
  1819.     
  1820.     window.__SS_state = aState;
  1821.     var _this = this;
  1822.     window.addEventListener("load", function(aEvent) {
  1823.       aEvent.currentTarget.removeEventListener("load", arguments.callee, true);
  1824.       _this.restoreWindow(aEvent.currentTarget, aEvent.currentTarget.__SS_state, true, true);
  1825.       delete aEvent.currentTarget.__SS_state;
  1826.     }, true);
  1827.   },
  1828.  
  1829.   /**
  1830.    * Whether or not to resume session, if not recovering from a crash.
  1831.    * @returns bool
  1832.    */
  1833.   _doResumeSession: function sss_doResumeSession() {
  1834.     return this._getPref("startup.page", 1) == 3 ||
  1835.       this._getPref("sessionstore.resume_session_once", DEFAULT_RESUME_SESSION_ONCE);
  1836.   },
  1837.  
  1838.   /**
  1839.    * whether the user wants to load any other page at startup
  1840.    * (except the homepage) - needed for determining whether to overwrite the current tabs
  1841.    * @returns bool
  1842.    */
  1843.   _isCmdLineEmpty: function sss_isCmdLineEmpty(aWindow) {
  1844.     var defaultArgs = Cc["@mozilla.org/browser/clh;1"].
  1845.                       getService(Ci.nsIBrowserHandler).defaultArgs;
  1846.     if (aWindow.arguments && aWindow.arguments[0] &&
  1847.         aWindow.arguments[0] == defaultArgs)
  1848.       aWindow.arguments[0] = null;
  1849.  
  1850.     return !aWindow.arguments || !aWindow.arguments[0];
  1851.   },
  1852.  
  1853.   /**
  1854.    * don't save sensitive data if the user doesn't want to
  1855.    * (distinguishes between encrypted and non-encrypted sites)
  1856.    * @param aIsHTTPS
  1857.    *        Bool is encrypted
  1858.    * @returns bool
  1859.    */
  1860.   _checkPrivacyLevel: function sss_checkPrivacyLevel(aIsHTTPS) {
  1861.     return this._getPref("sessionstore.privacy_level", DEFAULT_PRIVACY_LEVEL) < (aIsHTTPS ? PRIVACY_ENCRYPTED : PRIVACY_FULL);
  1862.   },
  1863.  
  1864.   /**
  1865.    * on popup windows, the XULWindow's attributes seem not to be set correctly
  1866.    * we use thus JSDOMWindow attributes for sizemode and normal window attributes
  1867.    * (and hope for reasonable values when maximized/minimized - since then
  1868.    * outerWidth/outerHeight aren't the dimensions of the restored window)
  1869.    * @param aWindow
  1870.    *        Window reference
  1871.    * @param aAttribute
  1872.    *        String sizemode | width | height | other window attribute
  1873.    * @returns string
  1874.    */
  1875.   _getWindowDimension: function sss_getWindowDimension(aWindow, aAttribute) {
  1876.     if (aAttribute == "sizemode") {
  1877.       switch (aWindow.windowState) {
  1878.       case aWindow.STATE_MAXIMIZED:
  1879.         return "maximized";
  1880.       case aWindow.STATE_MINIMIZED:
  1881.         return "minimized";
  1882.       default:
  1883.         return "normal";
  1884.       }
  1885.     }
  1886.     
  1887.     var dimension;
  1888.     switch (aAttribute) {
  1889.     case "width":
  1890.       dimension = aWindow.outerWidth;
  1891.       break;
  1892.     case "height":
  1893.       dimension = aWindow.outerHeight;
  1894.       break;
  1895.     default:
  1896.       dimension = aAttribute in aWindow ? aWindow[aAttribute] : "";
  1897.       break;
  1898.     }
  1899.     
  1900.     if (aWindow.windowState == aWindow.STATE_NORMAL) {
  1901.       return dimension;
  1902.     }
  1903.     return aWindow.document.documentElement.getAttribute(aAttribute) || dimension;
  1904.   },
  1905.  
  1906.   /**
  1907.    * Convenience method to get localized string bundles
  1908.    * @param aURI
  1909.    * @returns nsIStringBundle
  1910.    */
  1911.   _getStringBundle: function sss_getStringBundle(aURI) {
  1912.      var bundleService = Cc["@mozilla.org/intl/stringbundle;1"].
  1913.                          getService(Ci.nsIStringBundleService);
  1914.      var appLocale = Cc["@mozilla.org/intl/nslocaleservice;1"].
  1915.                      getService(Ci.nsILocaleService).getApplicationLocale();
  1916.      return bundleService.createBundle(aURI, appLocale);
  1917.   },
  1918.  
  1919.   /**
  1920.    * Get nsIURI from string
  1921.    * @param string
  1922.    * @returns nsIURI
  1923.    */
  1924.    _getURIFromString: function sss_getURIFromString(aString) {
  1925.      var ioService = Cc["@mozilla.org/network/io-service;1"].
  1926.                      getService(Ci.nsIIOService);
  1927.      return ioService.newURI(aString, null, null);
  1928.    },
  1929.  
  1930.   /**
  1931.    * safe eval'ing
  1932.    */
  1933.   _safeEval: function sss_safeEval(aStr) {
  1934.     var s = new Components.utils.Sandbox("about:blank");
  1935.     return Components.utils.evalInSandbox(aStr, s);
  1936.   },
  1937.  
  1938.   /**
  1939.    * Converts a JavaScript object into a JSON string
  1940.    * (see http://www.json.org/ for the full grammar).
  1941.    *
  1942.    * The inverse operation consists of eval("(" + JSON_string + ")");
  1943.    * and should be provably safe.
  1944.    *
  1945.    * @param aJSObject is the object to be converted
  1946.    * @return the object's JSON representation
  1947.    */
  1948.   _toJSONString: function sss_toJSONString(aJSObject) {
  1949.     // these characters have a special escape notation
  1950.     const charMap = { "\b": "\\b", "\t": "\\t", "\n": "\\n", "\f": "\\f",
  1951.                       "\r": "\\r", '"': '\\"', "\\": "\\\\" };
  1952.     // we use a single string builder for efficiency reasons
  1953.     var parts = [];
  1954.     
  1955.     // this recursive function walks through all objects and appends their
  1956.     // JSON representation to the string builder
  1957.     function jsonIfy(aObj) {
  1958.       if (typeof aObj == "boolean") {
  1959.         parts.push(aObj ? "true" : "false");
  1960.       }
  1961.       else if (typeof aObj == "number" && isFinite(aObj)) {
  1962.         // there is no representation for infinite numbers or for NaN!
  1963.         parts.push(aObj.toString());
  1964.       }
  1965.       else if (typeof aObj == "string") {
  1966.         aObj = aObj.replace(/[\\"\x00-\x1F\u0080-\uFFFF]/g, function($0) {
  1967.           // use the special escape notation if one exists, otherwise
  1968.           // produce a general unicode escape sequence
  1969.           return charMap[$0] ||
  1970.             "\\u" + ("0000" + $0.charCodeAt(0).toString(16)).slice(-4);
  1971.         });
  1972.         parts.push('"' + aObj + '"')
  1973.       }
  1974.       else if (aObj == null) {
  1975.         parts.push("null");
  1976.       }
  1977.       else if (aObj instanceof Array) {
  1978.         parts.push("[");
  1979.         for (var i = 0; i < aObj.length; i++) {
  1980.           jsonIfy(aObj[i]);
  1981.           parts.push(",");
  1982.         }
  1983.         if (parts[parts.length - 1] == ",")
  1984.           parts.pop(); // drop the trailing colon
  1985.         parts.push("]");
  1986.       }
  1987.       else if (typeof aObj == "object") {
  1988.         parts.push("{");
  1989.         for (var key in aObj) {
  1990.           if (key == "_tab")
  1991.             continue; // XXXzeniko we might even want to drop all private members
  1992.           
  1993.           jsonIfy(key.toString());
  1994.           parts.push(":");
  1995.           jsonIfy(aObj[key]);
  1996.           parts.push(",");
  1997.         }
  1998.         if (parts[parts.length - 1] == ",")
  1999.           parts.pop(); // drop the trailing colon
  2000.         parts.push("}");
  2001.       }
  2002.       else {
  2003.         throw new Error("No JSON representation for this object!");
  2004.       }
  2005.     }
  2006.     jsonIfy(aJSObject);
  2007.     
  2008.     var newJSONString = parts.join(" ");
  2009.     // sanity check - so that API consumers can just eval this string
  2010.     if (/[^,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]/.test(
  2011.       newJSONString.replace(/"(\\.|[^"\\])*"/g, "")
  2012.     ))
  2013.       throw new Error("JSON conversion failed unexpectedly!");
  2014.     
  2015.     return newJSONString;
  2016.   },
  2017.  
  2018. /* ........ Storage API .............. */
  2019.  
  2020.   /**
  2021.    * basic pref reader
  2022.    * @param aName
  2023.    * @param aDefault
  2024.    * @param aUseRootBranch
  2025.    */
  2026.   _getPref: function sss_getPref(aName, aDefault) {
  2027.     var pb = this._prefBranch;
  2028.     try {
  2029.       switch (pb.getPrefType(aName)) {
  2030.       case pb.PREF_STRING:
  2031.         return pb.getCharPref(aName);
  2032.       case pb.PREF_BOOL:
  2033.         return pb.getBoolPref(aName);
  2034.       case pb.PREF_INT:
  2035.         return pb.getIntPref(aName);
  2036.       default:
  2037.         return aDefault;
  2038.       }
  2039.     }
  2040.     catch(ex) {
  2041.       return aDefault;
  2042.     }
  2043.   },
  2044.  
  2045.   /**
  2046.    * write file to disk
  2047.    * @param aFile
  2048.    *        nsIFile
  2049.    * @param aData
  2050.    *        String data
  2051.    */
  2052.   _writeFile: function sss_writeFile(aFile, aData) {
  2053.     // init stream
  2054.     var stream = Cc["@mozilla.org/network/safe-file-output-stream;1"].
  2055.                  createInstance(Ci.nsIFileOutputStream);
  2056.     stream.init(aFile, 0x02 | 0x08 | 0x20, 0600, 0);
  2057.  
  2058.     // convert to UTF-8
  2059.     var converter = Cc["@mozilla.org/intl/scriptableunicodeconverter"].
  2060.                     createInstance(Ci.nsIScriptableUnicodeConverter);
  2061.     converter.charset = "UTF-8";
  2062.     var convertedData = converter.ConvertFromUnicode(aData);
  2063.     convertedData += converter.Finish();
  2064.  
  2065.     // write and close stream
  2066.     stream.write(convertedData, convertedData.length);
  2067.     if (stream instanceof Ci.nsISafeOutputStream) {
  2068.       stream.finish();
  2069.     } else {
  2070.       stream.close();
  2071.     }
  2072.   },
  2073.  
  2074. /* ........ QueryInterface .............. */
  2075.  
  2076.   QueryInterface: function(aIID) {
  2077.     if (!aIID.equals(Ci.nsISupports) && 
  2078.       !aIID.equals(Ci.nsIObserver) && 
  2079.       !aIID.equals(Ci.nsISupportsWeakReference) && 
  2080.       !aIID.equals(Ci.nsIDOMEventListener) &&
  2081.       !aIID.equals(Ci.nsISessionStore)) {
  2082.       Components.returnCode = Cr.NS_ERROR_NO_INTERFACE;
  2083.       return null;
  2084.     }
  2085.     
  2086.     return this;
  2087.   }
  2088. };
  2089.  
  2090. /* :::::::::: Asynchronous File Downloader :::::::::::::: */
  2091.  
  2092. function AutoDownloader(aURL, aFilename, aWindow) {
  2093.    this._URL = aURL;
  2094.    this._filename = aFilename;
  2095.    this._window = aWindow;
  2096. }
  2097.  
  2098. AutoDownloader.prototype = {
  2099.   onStartRequest: function(aRequest, aContext) { },
  2100.   onStopRequest: function(aRequest, aContext, aStatus) {
  2101.     if (Components.isSuccessCode(aStatus)) {
  2102.       var file =
  2103.         Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsILocalFile);
  2104.       file.initWithPath(this._filename);
  2105.       if (file.exists()) {
  2106.         file.remove(false);
  2107.       }
  2108.       
  2109.       this._window.saveURL(this._URL, this._filename, null, true, true, null);
  2110.     }
  2111.   }
  2112. };
  2113.  
  2114. /* :::::::: Service Registration & Initialization ::::::::::::::: */
  2115.  
  2116. /* ........ nsIModule .............. */
  2117.  
  2118. const SessionStoreModule = {
  2119.  
  2120.   getClassObject: function(aCompMgr, aCID, aIID) {
  2121.     if (aCID.equals(CID)) {
  2122.       return SessionStoreFactory;
  2123.     }
  2124.     
  2125.     Components.returnCode = Cr.NS_ERROR_NOT_REGISTERED;
  2126.     return null;
  2127.   },
  2128.  
  2129.   registerSelf: function(aCompMgr, aFileSpec, aLocation, aType) {
  2130.     aCompMgr.QueryInterface(Ci.nsIComponentRegistrar);
  2131.     aCompMgr.registerFactoryLocation(CID, CLASS_NAME, CONTRACT_ID, aFileSpec, aLocation, aType);
  2132.  
  2133.     var catMan = Cc["@mozilla.org/categorymanager;1"].
  2134.                  getService(Ci.nsICategoryManager);
  2135.     catMan.addCategoryEntry("app-startup", CLASS_NAME, "service," + CONTRACT_ID, true, true);
  2136.   },
  2137.  
  2138.   unregisterSelf: function(aCompMgr, aLocation, aType) {
  2139.     aCompMgr.QueryInterface(Ci.nsIComponentRegistrar);
  2140.     aCompMgr.unregisterFactoryLocation(CID, aLocation);
  2141.  
  2142.     var catMan = Cc["@mozilla.org/categorymanager;1"].
  2143.                  getService(Ci.nsICategoryManager);
  2144.     catMan.deleteCategoryEntry( "app-startup", "service," + CONTRACT_ID, true);
  2145.   },
  2146.  
  2147.   canUnload: function(aCompMgr) {
  2148.     return true;
  2149.   }
  2150. }
  2151.  
  2152. /* ........ nsIFactory .............. */
  2153.  
  2154. const SessionStoreFactory = {
  2155.  
  2156.   createInstance: function(aOuter, aIID) {
  2157.     if (aOuter != null) {
  2158.       Components.returnCode = Cr.NS_ERROR_NO_AGGREGATION;
  2159.       return null;
  2160.     }
  2161.     
  2162.     return (new SessionStoreService()).QueryInterface(aIID);
  2163.   },
  2164.  
  2165.   lockFactory: function(aLock) { },
  2166.  
  2167.   QueryInterface: function(aIID) {
  2168.     if (!aIID.equals(Ci.nsISupports) && !aIID.equals(Ci.nsIModule) &&
  2169.         !aIID.equals(Ci.nsIFactory) && !aIID.equals(Ci.nsISessionStore)) {
  2170.       Components.returnCode = Cr.NS_ERROR_NO_INTERFACE;
  2171.       return null;
  2172.     }
  2173.     
  2174.     return this;
  2175.   }
  2176. };
  2177.  
  2178. function NSGetModule(aComMgr, aFileSpec) {
  2179.   return SessionStoreModule;
  2180. }
  2181.